home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / programr / drdobbs.zip / HELPDUMP.C < prev    next >
Text File  |  1993-08-02  |  41KB  |  1,233 lines
  1. /***************************************************
  2.   HLPDUMP1.C
  3.   Peter Davis - 05/93
  4.  
  5.   Taken from the original HELPDUMP.C written by
  6. Ron Burk.
  7.  
  8.   Dumps known files from WinHelp internal file
  9. system in a formatted output. If WHIFS file is
  10. unknown, hex/ascii dump of file is taken.
  11.  
  12.   HELPDUMP.C will replace HLPDUMP1.C with extended
  13. functionality for handling more WHIFS files.
  14.  
  15. ****************************************************/
  16.  
  17.  
  18. /*************************************************
  19.    If it's not Turbo C, assume MSC 6.0 As for the
  20.    rest of you, you'll have to customize. Sorry.
  21. **************************************************/
  22.  
  23. #pragma pack(1)   /* Make sure we get byte alignment */
  24.  
  25. #ifndef __TURBOC__
  26.   #include <graph.h>
  27.   #define clrscr() _clearscreen(_GCLEARSCREEN);
  28. #endif
  29.  
  30. #include <time.h>
  31. #include <stdio.h>
  32. #include <stdlib.h>
  33. #include <string.h>
  34. #include <conio.h>
  35. #include <ctype.h>
  36. #include <limits.h>
  37. #include "whstruct.h"
  38. #include "helpdump.h"
  39.  
  40. HELPHEADER        HelpHeader;             /* Header for Help file.         */
  41. WHIFSBTREEHEADER  WHIFSHeader;            /* WHIFS Header record           */
  42. int               WHIFSLeafOne = -1;      /* First WHIFS Leaf Node         */
  43. long              FirstPageLoc;           /* Used by macros for b-trees    */
  44. char              WHIFSFileToRead[19];    /* Internal file to dump         */
  45. int               ReadWHIFSFile;          /* Flag to dump an internal file */
  46. SYSTEMHEADER      SysHeader;              /* Global System Header Record   */
  47. char              *PhrasesPtr; 
  48. int               TopicUse;
  49.  
  50.  
  51. /***************************************************
  52.   Finds the first leaf in the WHIFS B-Tree
  53. ****************************************************/
  54. void WHIFSGetFirstLeaf(FILE *HelpFile) {
  55.     
  56.     int               CurrLevel = 1;  /* Current Level in B-Tree */
  57.     BTREEINDEXHEADER  CurrNode;       /* Current Node in B-Tree  */
  58.     int               NextPage = 0;   /* Next Page to go to      */
  59.  
  60.     /* Go to the beginning of WHIFS B-Tree */
  61.     fseek(HelpFile, HelpHeader.WHIFS, SEEK_SET);
  62.     fread(&WHIFSHeader, sizeof(WHIFSHeader), 1, HelpFile);
  63.  
  64.     FirstPageLoc = HelpHeader.WHIFS + sizeof(WHIFSHeader);
  65.  
  66.     /* Find First Leaf */
  67.     while (CurrLevel < WHIFSHeader.NLevels) {
  68.        fread(&CurrNode, sizeof(CurrNode), 1, HelpFile);
  69.  
  70.        /* Next Page is conveniently the first byte of the page */
  71.        fread(&NextPage, sizeof(int), 1, HelpFile);
  72.        GotoWHIFSPage(NextPage);
  73.        CurrLevel++;
  74.     }
  75.  
  76.     /* First Leaf page is here */
  77.     WHIFSLeafOne = NextPage;
  78. }
  79.        
  80.     
  81.  
  82.  
  83.  
  84. /***************************************************
  85.   Gets a particular file by file number.
  86.   Needs the root node of the tree.
  87.   Returns the offset of the file and the filename.
  88. ****************************************************/
  89.  
  90. void GetFile(FILE *HelpFile, int FileNumber, long *FileOffset, char *FileName) {
  91.  
  92.     BTREENODEHEADER CurrentNode;      
  93.     int             CurrPage;              /* Keep track of page # */
  94.     int             Index, counter = 0;
  95.     char            c, TempFile[19];
  96.  
  97.     
  98.     /* Skip pages we don't need */
  99.     CurrentNode.NextPage = WHIFSLeafOne;
  100.     do {
  101.         CurrPage = CurrentNode.NextPage;
  102.         GotoWHIFSPage(CurrPage);
  103.         fread(&CurrentNode, sizeof(CurrentNode), 1, HelpFile);
  104.         counter += CurrentNode.NEntries;
  105.     } while (counter < FileNumber);
  106.  
  107.     for (counter -= CurrentNode.NEntries; counter <= FileNumber; counter++) {
  108.         Index = 0;
  109.     while(c = fgetc(HelpFile))
  110.             TempFile[Index++] = c;
  111.          
  112.         TempFile[Index] = 0;  /* End of line */
  113.         fread(FileOffset, sizeof(long), 1, HelpFile);
  114.     }
  115.     strcpy(FileName, TempFile);
  116.  
  117. }
  118.  
  119.  
  120. /***************************************************
  121.   Loads the SysHeader into memory. Need this later
  122. on to determine if compression is used on help file.
  123. ****************************************************/
  124.  
  125. void SysLoad(FILE *HelpFile, long FileStart) {
  126.  
  127.    FILEHEADER      FileHdr;
  128.  
  129.    fseek(HelpFile, FileStart, SEEK_SET);
  130.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  131.    fread(&SysHeader, sizeof(SysHeader), 1, HelpFile);
  132.  
  133. }
  134.  
  135.  
  136. /*************************************************
  137.   Returns a 1 if the bit is set, else 0 returned
  138. **************************************************/
  139.  
  140. int BitSet(BYTE BitMap, int Bit) {
  141.   
  142.    if (BitMap & (1<<Bit)) return 1;
  143.                      else return 0;
  144.  
  145. }
  146.  
  147.  
  148. /*************************************************
  149.   Decides how many bytes to read, depending on the
  150.   number of bits set in the Bitmap
  151. **************************************************/
  152.  
  153. int BytesToRead(BYTE BitMap) {
  154.  
  155. int TempSum, counter;
  156.  
  157.     TempSum = 8;
  158.     for (counter = 0; counter < 8; counter ++)
  159.        TempSum += BitSet(BitMap, counter);
  160.  
  161.     return TempSum;
  162. }
  163.  
  164.  
  165. /*************************************************
  166.   Decompresses the data using Microsoft's LZ77
  167. derivative.
  168. **************************************************/ 
  169.  
  170. WORD Decompress(FILE *HelpFile, WORD CompSize, char *Buffer) {
  171.  
  172. WORD InBytes = 0;        /* How many bytes read in                    */
  173. WORD OutBytes = 0;       /* How many bytes written out                */
  174. BYTE BitMap, Set[16];    /* Bitmap and bytes associated with it       */
  175. int  NumToRead;          /* Number of bytes to read for next group    */
  176. int  counter, Index;     /* Going through next 8-16 codes or chars    */
  177. int  Length, Distance;   /* Code length and distance back in 'window' */
  178. char *CurrPos;           /* Where we are at any given moment          */
  179. char *CodePtr;           /* Pointer to back-up in LZ77 'window'       */
  180.  
  181.  
  182.    CurrPos = Buffer;
  183.  
  184.    /* Go through until we're done */
  185.    while (InBytes < CompSize) {
  186.  
  187.       /* Get BitMap and data following it */
  188.       BitMap = fgetc(HelpFile);
  189.       NumToRead = BytesToRead(BitMap);
  190.  
  191.       /* If we're trying to read more than we've got left, only read what we have left. */
  192.       NumToRead = (CompSize - InBytes) < NumToRead ? CompSize-InBytes : NumToRead;
  193.  
  194.       fread(Set, 1, NumToRead, HelpFile);    
  195.       InBytes += NumToRead + 1;
  196.  
  197.       /* Go through and decode data */
  198.       for (counter = 0, Index = 0; counter < 8; counter++) {
  199.  
  200.          /* It's a code, so decode it and copy the data */
  201.          if (BitSet(BitMap, counter)) {
  202.             Length = ((Set[Index+1] & 0xF0) >> 4) + 3;
  203.             Distance = (256 * (Set[Index+1] & 0x0F)) + Set[Index] + 1;
  204.  
  205.             CodePtr = CurrPos - Distance;
  206.  
  207.             /* Copy data from 'window' */
  208.             while (Length) {
  209.                *CurrPos++ = *CodePtr++;
  210.                OutBytes++;
  211.                Length--;
  212.             } 
  213.  
  214.             Index += 2;
  215.  
  216.          } /* if */
  217.  
  218.          else {
  219.             *CurrPos++ = Set[Index++];
  220.             OutBytes++;
  221.          }
  222.  
  223.       } /* for */
  224.  
  225.    } /* while  */
  226.  
  227.    return OutBytes;
  228. } 
  229.    
  230.  
  231. /***************************************************
  232.   List the WHIFS directory to the screen.
  233. ****************************************************/
  234.  
  235. void ListFiles(FILE *HelpFile) {
  236.  
  237.     DWORD           FileCounter;
  238.     char            FileName[20];
  239.     long            FileOffset;
  240.  
  241.  
  242.     /* Load WHIFS Header and Get first leaf */
  243.     WHIFSGetFirstLeaf(HelpFile);
  244.  
  245.     for (FileCounter = 0;
  246.          FileCounter < WHIFSHeader.TotalWHIFSEntries;
  247.          FileCounter++) {
  248.  
  249.         GetFile(HelpFile, FileCounter, &FileOffset, FileName);
  250.  
  251.         printf("File:%-10s FileOffset:0x%08lX ",FileName, FileOffset);
  252.  
  253.         /* Make it double column */
  254.         if ((FileCounter % 2) != 0) printf("\n");
  255.              else printf("|");
  256.     }
  257.  
  258. }
  259.  
  260.  
  261. /***************************************************
  262.   Performs a Hex/ASCII dump of a WHIFS file.
  263. ****************************************************/
  264.  
  265. void HexDump(FILE *HelpFile, long FileStart) {
  266.  
  267.    FILEHEADER  FileHdr;
  268.    char        Buffer[16];
  269.    long        counter;
  270.    int         BytesToPrint, Index;
  271.  
  272.  
  273.    fseek(HelpFile, FileStart, SEEK_SET);
  274.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  275.  
  276.    printf("File Size: 0x%08lX\n\n", FileHdr.FileSize);
  277.  
  278.    printf("Offset                   Hex Values                           Ascii\n");
  279.    printf("-------------------------------------------------------------------------\n");
  280.  
  281.    for (counter = 0; counter < FileHdr.FileSize; counter+=16) {
  282.  
  283.       printf("0x%08lX: ", counter);
  284.  
  285.       /* If this is the last line, how many bytes are in it? */
  286.       BytesToPrint = ((FileHdr.FileSize - counter) > 16) ? 16 : FileHdr.FileSize - counter;
  287.       fread(Buffer, BytesToPrint, 1, HelpFile);
  288.  
  289.       /* Dump Hex */
  290.       for (Index=0; Index < BytesToPrint; Index++)
  291.           printf("%02X ", (BYTE) Buffer[Index]);
  292.  
  293.       /* If last line, fill in blanks */
  294.       for (Index=0; Index < 16-BytesToPrint; Index++) 
  295.           printf("   ");
  296.  
  297.       /* Dump Ascii */
  298.       for (Index=0; Index < BytesToPrint; Index++) 
  299.           putchar( isprint( Buffer[Index] ) ? Buffer[Index] : '.' );
  300.  
  301.       putchar('\n');
  302.    }
  303.  
  304.    free(Buffer);
  305. }
  306.  
  307.  
  308.  
  309.  
  310. /***************************************************
  311.   Display information about the |SYSTEM file.
  312. ****************************************************/
  313.  
  314. void SysDump(FILE *HelpFile, long FileStart) {
  315.  
  316.    FILEHEADER      FileHdr;
  317.    char            HelpFileTitle[33];
  318.    SYSTEMREC       SystemRec;
  319.    WORD            CurrentLocation;
  320.    struct tm       *TimeRec;
  321.    SECWINDOW       *SWin;     /* Secondary Window record */
  322.  
  323.    fseek(HelpFile, FileStart, SEEK_SET);
  324.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  325.    fread(&SysHeader, sizeof(SysHeader), 1, HelpFile);
  326.    printf("|SYSTEM Dump\n\n\n");
  327.  
  328.    /* Figure out Version and Revision */
  329.    if (SysHeader.Revision == 0x0F) printf("HC.EXE  3.00 Help Compiler used\n");
  330.    else if (SysHeader.Revision == 0x15) printf("HC.EXE  3.10 Help Compiler used\n");
  331.    else if (SysHeader.Revision == 0x21) printf("MVC.EXE  Multimedia Compiler used.\n");
  332.    else printf("Unknown Compiler used!\n");
  333.  
  334.    printf("\nVersion: %d\nRevision: %d\n", SysHeader.Version, SysHeader.Revision);
  335.    printf("Flag: 0x%04X  - ",SysHeader.Flags);
  336.  
  337.    /* Determine compression, if any. */
  338.    if (SysHeader.Flags == 0x00) printf("No compression\n");
  339.    else if (SysHeader.Flags & COMPRESSION_310) printf("Compressed\n");
  340.    else if (SysHeader.Flags & COMPRESSION_UNKN) printf("Compressed\n");
  341.    else printf("Unknown\n");
  342.  
  343.    TimeRec=localtime(&SysHeader.GenDate);
  344.    printf("Help File Generated: %s", asctime(TimeRec));
  345.  
  346.    /* If 3.0 get title */
  347.    CurrentLocation=12;
  348.    if (SysHeader.Revision == 0x0F) {
  349.       fgets(HelpFileTitle, 33, HelpFile);
  350.       printf("Help File Title: %s\n", HelpFileTitle);
  351.    }
  352.  
  353.    /* Else, get 3.1 System records */
  354.    else {
  355.       while (CurrentLocation < FileHdr.FileSize) {
  356.  
  357.          /* Read in system record and SystemRec data */
  358.          fread(&SystemRec, 4, 1, HelpFile);
  359.          SystemRec.RData = malloc(SystemRec.DataSize);
  360.          fread(SystemRec.RData, SystemRec.DataSize, 1, HelpFile);
  361.          CurrentLocation=CurrentLocation+4+SystemRec.DataSize;
  362.  
  363.          switch(SystemRec.RecordType) {
  364.              case 0x0001:  printf("Help File Title: %s\n", SystemRec.RData);
  365.                    break;
  366.  
  367.              case 0x0002:  printf("Copyright Notice: %s\n", SystemRec.RData);
  368.                    break;
  369.  
  370.              case 0x0003:  printf("Contents ID: 0x%04X\n", (long) *SystemRec.RData);
  371.                    break;
  372.  
  373.              case 0x0004:  printf("Macro Data: %s\n",SystemRec.RData);
  374.                    break;
  375.  
  376.              case 0x0005:  printf("Icon in System record\n");
  377.                    break;
  378.  
  379.              case 0x0006:  printf("\nSecondary window:\n");
  380.                            SWin = (SECWINDOW *)SystemRec.RData;
  381.                            printf("Flag: %d\n", SWin->Flags);
  382.                            if (SWin->Flags & WSYSFLAG_TYPE) 
  383.                               printf("Type: %s\n", SWin->Type);
  384.                            if (SWin->Flags & WSYSFLAG_NAME) 
  385.                               printf("Name: %s\n", SWin->Name);
  386.                            if (SWin->Flags & WSYSFLAG_CAPTION) 
  387.                               printf("Caption: %s\n", SWin->Caption);
  388.                            if (SWin->Flags & WSYSFLAG_X) 
  389.                               printf("X: %d\n", SWin->X);
  390.                            if (SWin->Flags & WSYSFLAG_Y) 
  391.                               printf("Y: %d\n", SWin->Y);
  392.                            if (SWin->Flags & WSYSFLAG_WIDTH)
  393.                               printf("Width: %d\n", SWin->Width);
  394.                            if (SWin->Flags & WSYSFLAG_HEIGHT)
  395.                               printf("Height: %d\n", SWin->Height);
  396.                            if (SWin->Flags & WSYSFLAG_MAXIMIZE) 
  397.                               printf("Maximize Flag: %d\n", SWin->Maximize);
  398.                            if (SWin->Flags & WSYSFLAG_RGB) 
  399.                               printf("RGB Foreground Colors Set\n");
  400.                            if (SWin->Flags & WSYSFLAG_RGBNSR)
  401.                               printf("RGB For Non-Scrollable Region Set\n");
  402.                            if (SWin->Flags & WSYSFLAG_TOP) 
  403.                               printf("Secondary Window is always On Top\n");
  404.                    break;
  405.  
  406.              case 0x0008:  printf("Citation: %s\n", SystemRec.RData);
  407.                    break;
  408.  
  409.              default:      printf("Unknown record type: 0x%04X\n",SystemRec.RecordType);
  410.  
  411.          } /* switch */
  412.  
  413.          free(SystemRec.RData);
  414.  
  415.       } /* while */
  416.    } /* else */
  417. } /* SysDump */
  418.  
  419.  
  420. /***************************************************
  421.   Prints a Phrase from the Phrase table.
  422. ****************************************************/
  423. void PrintPhrase(char *Phrases, int PhraseNum) {
  424.  
  425.     int  *Offsets;
  426.     char *p;
  427.  
  428.     Offsets = (int *)Phrases;
  429.  
  430.     p = Phrases+Offsets[PhraseNum];
  431.     while (p < Phrases + Offsets[PhraseNum + 1])
  432.        putchar(*p++);
  433.  
  434.  
  435. }
  436.  
  437. /***************************************************
  438.    List all of the phrases if they're uncompressed.
  439.    If they're compressed, dump the hex/ascii.
  440. ****************************************************/
  441.  
  442. void PhraseDump(FILE *HelpFile, long FileStart) {
  443.  
  444.    FILEHEADER      FileHdr;
  445.    PHRASEHDR       PhraseHdr;
  446.    int             *Offsets, counter;
  447.    char            *Phrases;
  448.    WORD            DeCompSize;
  449.  
  450.    /* Go to the phrases file and get the headers */
  451.    fseek(HelpFile, FileStart, SEEK_SET);
  452.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  453.    fread(&PhraseHdr, sizeof(PhraseHdr), 1, HelpFile);
  454.  
  455.  
  456.    if (!TopicUse) printf("Phrase#  -  Phrase\n");
  457.  
  458.  
  459.    /* Allocate space and decompress if it's compressed, else read in. */
  460.    if ((SysHeader.Flags & COMPRESSION_310) || (SysHeader.Flags & COMPRESSION_UNKN)) {
  461.       if ((Offsets = malloc(PhraseHdr.PhrasesSize + (PhraseHdr.NumPhrases + 1) * 2)) == NULL) {
  462.          printf("No room to decompress |Phrases.");
  463.          return;
  464.       }
  465.       Phrases = Offsets + fread(Offsets, 2, PhraseHdr.NumPhrases+1, HelpFile);
  466.       DeCompSize = Decompress(HelpFile,
  467.                               FileHdr.FileSize - (sizeof(PhraseHdr) + 2 * (PhraseHdr.NumPhrases+1)),
  468.                               Phrases);
  469.       if (DeCompSize != PhraseHdr.PhrasesSize) {
  470.          printf("The amount of data after decompression does not match\n");
  471.          printf("the expected size from the Phrase Header!!!\n\n");
  472.       }
  473.  
  474.    } /* if */
  475.  
  476.      /* Else, no compression, so just read in the data */
  477.    else {
  478.       if ((Offsets = malloc(FileHdr.FileSize - sizeof(PhraseHdr))) == NULL) {
  479.          printf("No room to decompress |Phrases.");     
  480.          return;
  481.       }
  482.       /* Backup 4 bytes for uncompressed Phrases (no PhrasesSize) */
  483.       fseek(HelpFile, -4, SEEK_CUR);
  484.       fread(Offsets, FileHdr.FileSize - 4, 1, HelpFile);
  485.    } /* else */
  486.  
  487.    Phrases = (char *) Offsets;
  488.    PhrasesPtr = Phrases;
  489.    if (TopicUse) return;
  490.  
  491.    for (counter=0; counter < PhraseHdr.NumPhrases; counter++) {
  492.       printf("\n%d    -  ", counter);
  493.       PrintPhrase(Phrases, counter);
  494.    }
  495.    free(Offsets);
  496. }
  497.  
  498.  
  499. /***************************************************
  500.    Lists all of the fonts and font descriptors.
  501.    Fonts are fixed length 20 followed by Font
  502.    descriptors of Fixed Length 11 bytes.
  503. ****************************************************/
  504.  
  505. void FontDump(FILE *HelpFile, long FileStart) {
  506.  
  507.    FILEHEADER      FileHdr;
  508.    FONTHEADER      FontHdr;
  509.    FONTDESCRIPTOR  FontDesc;
  510.    char            AFont[20];
  511.    long            FontStart, CurrLoc;
  512.    int             counter;
  513.  
  514.    /* Go to the FONT file and get the headers */
  515.    fseek(HelpFile, FileStart, SEEK_SET);
  516.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  517.    fread(&FontHdr, sizeof(FontHdr), 1, HelpFile);
  518.  
  519.    printf("|FONTS\n\n Number Fonts: %d\n",FontHdr.NumFonts);
  520.    printf("Font #  -  Font Name\n");
  521.  
  522.    /* Keep track of start of fonts */
  523.    FontStart = ftell(HelpFile);
  524.    for (counter = 0; counter < FontHdr.NumFonts; counter++) {
  525.        fread(AFont, 20, 1, HelpFile);
  526.        printf(" %3d    -  %s\n", counter, AFont);
  527.    }
  528.  
  529.    /* Go to Font Descriptors. Don't actually need this, because we're
  530.       there, but wanted to show how to get there using the offset.    */
  531.    fseek(HelpFile, FontStart + (long)(FontHdr.DescriptorsOffset) - sizeof(FontHdr), SEEK_SET); 
  532.    printf("\nNum Font Descriptors: %d\n", FontHdr.NumDescriptors);
  533.    printf("Default Descriptor: %d\n\n", FontHdr.DefDescriptor);
  534.    printf("Attributes: n=none  b=bold  i=ital  u=undr  s=strkout  d=dblundr  C=smallcaps\n\n");
  535.    printf("Font Name            PointSize  Family   FG RGB      BG RGB     Attributes\n");
  536.    printf("--------------------------------------------------------------------------\n");
  537.  
  538.    for (counter = 0; counter < FontHdr.NumDescriptors; counter++) {
  539.       fread(&FontDesc, sizeof(FontDesc), 1, HelpFile);
  540.       CurrLoc = ftell(HelpFile);
  541.       fseek(HelpFile, FontStart + (20L * FontDesc.FontName), SEEK_SET);
  542.       fread(AFont, 20, 1, HelpFile);
  543.       fseek(HelpFile, CurrLoc, SEEK_SET);
  544.       
  545.       /* write out info on Font descriptor */
  546.       printf("%-20s    %4.1f    ", AFont, (float)(FontDesc.HalfPoints / 2));
  547.       switch (FontDesc.FontFamily) {
  548.          case FAM_MODERN: printf("Modern");
  549.                           break;
  550.  
  551.          case FAM_ROMAN:  printf("Roman ");
  552.                           break;
  553.  
  554.          case FAM_SWISS:  printf("Swiss ");
  555.                           break;
  556.  
  557.          case FAM_SCRIPT: printf("Script");
  558.                           break;
  559.  
  560.          case FAM_DECOR:  printf("Decor ");
  561.                           break;
  562.  
  563.          default:         printf("0X%02X ", FontDesc.FontFamily);
  564.                           break;
  565.       } /* Switch */
  566.       printf(" 0X%08lX  ",RGB(FontDesc.FGRGB[0], FontDesc.FGRGB[1], FontDesc.FGRGB[2]));
  567.       printf("0X%08lX    ",RGB(FontDesc.BGRGB[0], FontDesc.BGRGB[1], FontDesc.BGRGB[2]));
  568.  
  569.       if (FontDesc.Attributes == 0) putchar('n');
  570.       if (FontDesc.Attributes & FONT_BOLD) putchar('b');
  571.       if (FontDesc.Attributes & FONT_ITAL) putchar('i');
  572.       if (FontDesc.Attributes & FONT_UNDR) putchar('u');
  573.       if (FontDesc.Attributes & FONT_STRK) putchar('s');
  574.       if (FontDesc.Attributes & FONT_DBUN) putchar('d');
  575.       if (FontDesc.Attributes & FONT_SMCP) putchar('C');
  576.       printf("\n");
  577.    }
  578. }
  579.  
  580.  
  581.  
  582. /***************************************************
  583.    Dumps the |TOMAP file. Simple list of topic
  584.    numbers and topic offsets.
  585. ****************************************************/
  586. void ToMapDump(FILE *HelpFile, long FileStart) {
  587.  
  588.    FILEHEADER   FileHdr;
  589.    TOMAPHEADER  ToMapHdr;
  590.    int          counter;
  591.  
  592.    /* Go to the TOMAP file and get the headers */
  593.    fseek(HelpFile, FileStart, SEEK_SET);
  594.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  595.    fread(&ToMapHdr, 64, 1, HelpFile);
  596.  
  597.    ToMapHdr.ToMapLen = (FileHdr.FileSize - (16 * 4)) / 4;
  598.    ToMapHdr.TopicPtr = malloc(ToMapHdr.ToMapLen);
  599.    fread(ToMapHdr.TopicPtr, ToMapHdr.ToMapLen, 1, HelpFile);
  600.  
  601.    printf("Topic #  -  Topic Start\n");
  602.    for (counter=0; counter < ToMapHdr.ToMapLen; counter++)
  603.        printf("%3d  -  0x%08lX\n", counter, ToMapHdr.TopicPtr[counter]);
  604.    free(ToMapHdr.TopicPtr);
  605. }
  606.  
  607.  
  608. /***************************************************
  609.    Because the topic file is broken into 4k blocks,
  610.    we'll have to handle all the reads. The main
  611.    idea is to filter out the TOPICBLOCKHEADERs and
  612.    do an decompression that needs doing.
  613. ****************************************************/
  614. long TopicRead(BYTE *Dest, long NumBytes, FILE *HelpFile) {
  615.  
  616.    static long        CurrBlockLoc = 0;   /* Where we are in the block  */
  617.    static BYTE        *DCmpBlock = NULL;  /* Block of uncompressed data */
  618.    static long        DecompSize;         /* Size of block after decomp */
  619.    static long        TopicStart, BlkNum; /* Start of |TOPIC file       */
  620.    int                BytesLeft;          /* # Bytes left to return     */
  621.    TOPICBLOCKHEADER   BlockHeader;
  622.    TOPICLINK          *TempLink;
  623.    long               EndOffset;
  624.  
  625.    /* If NumBytes = 0, then we're done and need to free memory */
  626.    if (NumBytes == -1) {
  627.      free(DCmpBlock);
  628.      return 0;
  629.    }
  630.  
  631.    /* Is this our first time in? If so, allocate space needed */
  632.    if (!DCmpBlock) {
  633.       if ((SysHeader.Flags & COMPRESSION_310) || (SysHeader.Flags & COMPRESSION_UNKN)) {
  634.      /* MS assumes up to 75% compression. That's a bit */
  635.      /* optimistic given the algorithm. Expect more    */
  636.      /* like 25%-30% at best. We'll go with 75% anyway */
  637.          DCmpBlock = malloc(4 * TopicBlockSize);
  638.  
  639.          /* Get the current Topic location */
  640.          TopicStart = ftell(HelpFile);
  641.   
  642.          /* We're at Block 0 */
  643.          BlkNum = 0;
  644.  
  645.          DecompSize = 0;   /* Set initial size to 0 */
  646.          if (!DCmpBlock) {
  647.              printf("Not enough memory to decompress |TOPIC file!\n");
  648.              return -1;
  649.          }
  650.  
  651.       }
  652.       else {
  653.  
  654.          DCmpBlock = malloc(TopicBlockSize);  /* Space needed for decompressed block */
  655.  
  656.          DecompSize = 0;  /* Set initial size to zero */
  657.          if (!DCmpBlock) {
  658.              printf("Not enough memory to handle a |TOPIC file!\n");
  659.              return -1;
  660.          }
  661.       }
  662.       /* Don't really need the first block header, so get it out of the way */
  663.       fread(&BlockHeader, sizeof(BlockHeader), 1, HelpFile);
  664.    }
  665.  
  666.    /* Get the info for the TopicRead */
  667.    BytesLeft = NumBytes;
  668.  
  669.    while (BytesLeft) {
  670.  
  671.       /* Do we need to read in a new block? */
  672.       if (DecompSize == CurrBlockLoc) {
  673.  
  674.       /* Increment the block number */
  675.          BlkNum++;
  676.          /* If it's a compressed block, decompress it */
  677.          if ((SysHeader.Flags & COMPRESSION_310) || (SysHeader.Flags & COMPRESSION_UNKN)) {
  678.                 DecompSize = Decompress(HelpFile, TopicBlockSize-1, DCmpBlock);
  679.             /* Align ourselves at next 4k block */
  680.             fseek(HelpFile, TopicStart + (4096L * BlkNum), SEEK_SET);
  681.          }
  682.          else
  683.             DecompSize = fread(DCmpBlock, 1, TopicBlockSize, HelpFile);
  684.  
  685.          CurrBlockLoc = 0;
  686.  
  687.  
  688.          /* This is the tricky part! If the block isn't full, */
  689.          /* we need to find the end of it and change          */
  690.          /* DecompSize to adjust to the real end. We do this  */
  691.          /* by reading the block header of the next block     */
  692.          /* and going to the last record in this block.       */
  693.          fread(&BlockHeader, sizeof(BlockHeader), 1, HelpFile);
  694.  
  695.          /* Get offset of last topic link. (Don't need the block #, hence 3FFFh) */
  696.          EndOffset = BlockHeader.LastTopicLink & 0x3FFF;
  697.          TempLink = (TOPICLINK *) (DCmpBlock + EndOffset - sizeof(BlockHeader) );
  698.  
  699.          /* Actual end of the data (Don't include header) */
  700.          EndOffset += (TempLink->BlockSize - sizeof(BlockHeader));
  701.  
  702.          /* If end is shorter than topic block, use it, otherwise topic block is full */
  703.          if (EndOffset > DecompSize) {
  704.              /* Adjust DecompSize if crossing 4k boundary */
  705.              EndOffset = TempLink->BlockSize - ((TempLink->NextBlock) & 0x3FFF);
  706.              DecompSize = (BlockHeader.LastTopicLink & 0x3FFF) + EndOffset;
  707.          }
  708.          else DecompSize = EndOffset;
  709.  
  710.      } /* If */
  711.  
  712.      *(Dest++) = *(DCmpBlock + (CurrBlockLoc++) );
  713.       BytesLeft--;
  714.    } /* While (BytesLeft) */
  715.    return NumBytes;
  716.  
  717. }
  718.  
  719.  
  720. /***************************************************
  721.    Displays a string from a topic link record. Checks
  722. for Phrase replacement and non-printable chars.
  723. ****************************************************/
  724.  
  725. void StringPrint(char *String, long Length) {
  726.  
  727.    BYTE            Byte1, Byte2;
  728.    int             CurChar, PhraseNum;
  729.    int             PostSpace;
  730.    long            counter;
  731.  
  732.    for(counter = 0; counter < Length; counter++) {
  733.       CurChar = * ((char *) (String + counter));
  734.  
  735.       /* Check for Phrase replacement! */
  736.       if ((CurChar > 0) && (CurChar < 10)) {
  737.          Byte1 = CurChar;
  738.          counter++;
  739.          CurChar = * ((char *) (String + counter));
  740.          Byte2 = CurChar;
  741.          PhraseNum = (256 * (Byte1 - 1) + Byte2);
  742.  
  743.          /* If there's a remainder, we have a space after the phrase */
  744.          PostSpace = PhraseNum % 2;
  745.          /* Divide Phrase number by 2 */
  746.          PhraseNum = PhraseNum / 2;
  747.          PrintPhrase(PhrasesPtr, PhraseNum);
  748.          if (PostSpace) putchar(' ');
  749.       }
  750.       else 
  751.          if (isprint(CurChar)) putchar(CurChar);
  752.             else printf("(0x%02X)", (CurChar & 0x00FF));
  753.    }
  754. }
  755. /***************************************************
  756.    List all of the phrases if they're uncompressed.
  757.    If they're compressed, dump the hex/ascii.
  758. ****************************************************/
  759.  
  760. void TopicDump(FILE *HelpFile, long FileStart) {
  761.  
  762.    FILEHEADER      FileHdr;
  763.    TOPICHEADER     *TopicHdr;
  764.    TOPICLINK       TopicLink;
  765.  
  766.    /* Go to the TOPIC file and get the headers */
  767.    fseek(HelpFile, FileStart, SEEK_SET);
  768.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  769.  
  770.  
  771.    do {
  772.       TopicRead((BYTE *) &TopicLink, sizeof(TopicLink) - 4, HelpFile);
  773.  
  774.       /* TopicLink.DataLen2 assumes you are doing Phrase replacement.  */
  775.       /* Since we're not, we don't know the length of the phrases that */
  776.       /* would be replaced. Therefore we're going to modify the value  */
  777.       /* of DataLen2 to reflect the value without phrase replacement.  */
  778.  
  779.       if ((SysHeader.Flags & COMPRESSION_310) || (SysHeader.Flags & COMPRESSION_UNKN))
  780.          TopicLink.DataLen2 = TopicLink.BlockSize - TopicLink.DataLen1;
  781.  
  782.  
  783.  
  784.       /* 21=sizeof(TopicLink) - LinkData1 & LinkData2 fields. */
  785.       TopicLink.LinkData1 = malloc(TopicLink.DataLen1 - 21);
  786.       if(!TopicLink.LinkData1) {
  787.           printf("Error allocating TopicLink.LinkData1!\n");
  788.           return;
  789.       }
  790.       TopicRead(TopicLink.LinkData1, TopicLink.DataLen1 - 21, HelpFile);
  791.       if (TopicLink.DataLen2 > 0) {
  792.           TopicLink.LinkData2 = malloc(TopicLink.DataLen2 + 1);
  793.           if(!TopicLink.LinkData2) {
  794.              printf("Error allocating TopicLink.LinkData2!\n");
  795.              return;
  796.           }
  797.           TopicRead(TopicLink.LinkData2, TopicLink.DataLen2, HelpFile);
  798.       }
  799.  
  800.  
  801.       /* Display a Topic Header record */
  802.       if (TopicLink.RecordType == TL_TOPICHDR) {
  803.          TopicHdr = (TOPICHEADER *)TopicLink.LinkData1;
  804.      printf("========================================================\n");
  805.          printf("Topic#: %ld     Block Size: %ld\n",
  806.                 TopicHdr->TopicNum,
  807.                 TopicHdr->BlockSize);
  808.  
  809.          if (TopicLink.DataLen2 > 0)
  810.             StringPrint(TopicLink.LinkData2, TopicLink.DataLen2);
  811.          else printf("\n");
  812.       }
  813.  
  814.       /* Show a 'text' type record. */
  815.       else if (TopicLink.RecordType == TL_DISPLAY) {
  816.          printf("--------------------------------------------------------\n");
  817.          printf("Block Size: %ld\n", TopicLink.BlockSize);
  818.          StringPrint(TopicLink.LinkData2, TopicLink.DataLen2);
  819.       }
  820.       printf("\n\n");
  821.       free(TopicLink.LinkData1);
  822.       if (TopicLink.DataLen2 > 0) free(TopicLink.LinkData2);
  823.    } while(TopicLink.NextBlock != -1);
  824. }
  825.  
  826. /***************************************************
  827.   Get First leaf. Used by TTLDump ,KWBTreeDump and
  828. ContextDump.
  829. ****************************************************/
  830. int OtherGetFirstLeaf(FILE *HelpFile, long FirstPageLoc, int LeafLevel) {
  831.  
  832.    int               CurrLevel = 1;
  833.    BTREEINDEXHEADER  CurrNode;
  834.    int               NextPage = 0;
  835.  
  836.  
  837.    while(CurrLevel < LeafLevel) {
  838.       fread(&CurrNode, 4, 1, HelpFile);
  839.  
  840.       fread(&NextPage, sizeof(int), 1, HelpFile);
  841.       GotoPage(NextPage);
  842.       CurrLevel++;
  843.    }
  844.  
  845.    return NextPage;
  846. }
  847.  
  848.  
  849. /***************************************************
  850.   Dumps the Topic Titles B-Tree
  851. ****************************************************/
  852.  
  853. void TTLDump(FILE *HelpFile, long FileStart) {
  854.  
  855.    FILEHEADER      FileHdr;
  856.    char            Title[80], c;
  857.    int             count, Index;
  858.    long            CurrPage, FirstPageLoc, TopicOffset;
  859.    BTREEHEADER     BTreeHdr;
  860.    BTREENODEHEADER CurrNode;
  861.  
  862.    /* Go to the TTLBTREE file and get the headers */
  863.    fseek(HelpFile, FileStart, SEEK_SET);
  864.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  865.    fread(&BTreeHdr, sizeof(BTreeHdr), 1, HelpFile);
  866.  
  867.    /* Save the current location */
  868.    FirstPageLoc = ftell(HelpFile);
  869.    GotoPage(BTreeHdr.RootPage);
  870.  
  871.    printf("# Titles in |TTLBTREE %lu\n\n", BTreeHdr.TotalBtreeEntries);
  872.    CurrPage = OtherGetFirstLeaf(HelpFile, FirstPageLoc, BTreeHdr.NLevels);
  873.  
  874.    do {
  875.        GotoPage(CurrPage);
  876.        fread(&CurrNode, 8, 1, HelpFile);
  877.        for(count = 1; count <= CurrNode.NEntries; count++) {
  878.  
  879.           fread(&TopicOffset, sizeof(TopicOffset), 1, HelpFile);
  880.  
  881.           Index = 0;
  882.       while(c = fgetc(HelpFile))
  883.              Title[Index++] = c;
  884.           Title[Index] = 0;
  885.  
  886.           printf("Topic Offset:0x%08lX  Title: %s\n", TopicOffset, Title);
  887.        }
  888.        CurrPage = CurrNode.NextPage;
  889.  
  890.    } while(CurrPage != -1);
  891. }
  892.  
  893.  
  894. /***************************************************
  895.   Dumps the Keyword Map file
  896. ****************************************************/
  897.  
  898. void KWMapDump(FILE *HelpFile, long FileStart) {
  899.  
  900.    FILEHEADER      FileHdr;
  901.    WORD            NumKWMaps, count;
  902.    KWMAPREC        KeywordMap;
  903.  
  904.    /* Go to the KWMAP file and get the headers */
  905.    fseek(HelpFile, FileStart, SEEK_SET);
  906.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  907.  
  908.    fread(&NumKWMaps, sizeof(NumKWMaps), 1, HelpFile);
  909.  
  910.    for(count = 1; count <= NumKWMaps; count++) {
  911.       fread(&KeywordMap, sizeof(KWMAPREC), 1, HelpFile);
  912.       printf("Record:%05u   First Keyword:0x%08lX     Leaf Page#:%05u\n", 
  913.              count, KeywordMap.FirstRec, KeywordMap.PageNum);
  914.    }
  915. }
  916.  
  917.  
  918. /***************************************************
  919.   Dumps the Keyword data file
  920. ****************************************************/
  921.  
  922. void KWDataDump(FILE *HelpFile, long FileStart) {
  923.  
  924.    FILEHEADER      FileHdr;
  925.    WORD            NumKWLocs, count;
  926.    long            TopicOffset;
  927.  
  928.    /* Go to the KWDATA file and get the headers */
  929.    fseek(HelpFile, FileStart, SEEK_SET);
  930.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  931.  
  932.    NumKWLocs = FileHdr.FileSize / 4;
  933.    printf("Number of Keyword Occurrances: %5u\n\n", NumKWLocs);
  934.  
  935.    for(count = 1; count <= NumKWLocs; count++) {
  936.       fread(&TopicOffset, sizeof(TopicOffset), 1, HelpFile);
  937.       printf("Occurance:%05u   Topic Offset:0x%08lX\n",
  938.              count, TopicOffset);
  939.    }
  940. }
  941.  
  942.  
  943. /***************************************************
  944.   Dumps the keyword B-Tree file
  945. ****************************************************/
  946.  
  947. void KWBTreeDump(FILE *HelpFile, long FileStart) {
  948.  
  949.    FILEHEADER      FileHdr;
  950.    char            c;
  951.    int             count, Index;
  952.    long            CurrPage, FirstPageLoc;
  953.    BTREEHEADER     BTreeHdr;
  954.    BTREENODEHEADER CurrNode;
  955.    KWBTREEREC      KWBRec;
  956.  
  957.    /* Go to the KWBTREE file and get the headers */
  958.    fseek(HelpFile, FileStart, SEEK_SET);
  959.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  960.    fread(&BTreeHdr, sizeof(BTreeHdr), 1, HelpFile);
  961.  
  962.    /* Save the current location */
  963.    FirstPageLoc = ftell(HelpFile);
  964.    GotoPage(BTreeHdr.RootPage);
  965.  
  966.    printf("# Keywords in |KWBTREE %lu\n\n", BTreeHdr.TotalBtreeEntries);
  967.    CurrPage = OtherGetFirstLeaf(HelpFile, FirstPageLoc, BTreeHdr.NLevels);
  968.  
  969.    do {
  970.        GotoPage(CurrPage);
  971.        fread(&CurrNode, 8, 1, HelpFile);
  972.        for(count = 1; count <= CurrNode.NEntries; count++) {
  973.  
  974.           Index = 0;
  975.           while(c = fgetc(HelpFile))
  976.              KWBRec.Keyword[Index++] = c;
  977.           KWBRec.Keyword[Index] = 0;
  978.  
  979.           fread(&KWBRec.Count, sizeof(int), 1, HelpFile);
  980.           fread(&KWBRec.KWDataOffset, sizeof(long), 1, HelpFile);
  981.          
  982.           printf("KWData Offset:0x%08lX    # Offsets:%05d    Keyword: %s\n", 
  983.                   KWBRec.KWDataOffset, KWBRec.Count, KWBRec.Keyword);
  984.        }
  985.        CurrPage = CurrNode.NextPage;
  986.  
  987.    } while(CurrPage != -1);
  988. }
  989.  
  990.  
  991.  
  992. /***************************************************
  993.   Dumps the Context file.
  994. ****************************************************/
  995.  
  996. void ContextDump(FILE *HelpFile, long FileStart) {
  997.  
  998.    int             count;
  999.    long            CurrPage, FirstPageLoc;
  1000.    BTREEHEADER     BTreeHdr;
  1001.    BTREENODEHEADER CurrNode;
  1002.    FILEHEADER      FileHdr;
  1003.    CONTEXTREC      ContextRec;
  1004.  
  1005.    /* Go to the CONTEXT file and get the headers */
  1006.    fseek(HelpFile, FileStart, SEEK_SET);
  1007.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  1008.    fread(&BTreeHdr, sizeof(BTreeHdr), 1, HelpFile);
  1009.  
  1010.    /* Save the current location */
  1011.    FirstPageLoc = ftell(HelpFile);
  1012.    GotoPage(BTreeHdr.RootPage);
  1013.  
  1014.    printf("# Values in hash table:%lu\n\n", BTreeHdr.TotalBtreeEntries);
  1015.  
  1016.    CurrPage = OtherGetFirstLeaf(HelpFile, FirstPageLoc, BTreeHdr.NLevels);
  1017.  
  1018.    do {
  1019.        GotoPage(CurrPage);
  1020.        fread(&CurrNode, 8, 1, HelpFile);
  1021.        for(count = 1; count <= CurrNode.NEntries; count++) {
  1022.  
  1023.           fread(&ContextRec, sizeof(ContextRec), 1, HelpFile);
  1024.          
  1025.           printf("Hash Value:%12ld      Topic Offset:0x%08lX\n", 
  1026.                   ContextRec.HashValue, ContextRec.TopicOffset);
  1027.        }
  1028.        CurrPage = CurrNode.NextPage;
  1029.  
  1030.    } while(CurrPage != -1);
  1031.  
  1032.  
  1033. }
  1034.  
  1035.  
  1036. /***************************************************
  1037.    Dump the Context map file. Real simple.
  1038. ****************************************************/
  1039.  
  1040. void CTXOMAPDump(FILE *HelpFile, long FileStart) {
  1041.  
  1042.    FILEHEADER      FileHdr;
  1043.    CTXOMAPREC      CTXORec;
  1044.    WORD            NumRecs, count;
  1045.  
  1046.    /* Go to the CTXOMAP file and get the headers */
  1047.    fseek(HelpFile, FileStart, SEEK_SET);
  1048.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  1049.  
  1050.    fread(&NumRecs, sizeof(NumRecs), 1, HelpFile);
  1051.    printf("Number of Context Mapping records: %u\n\n", NumRecs);
  1052.    
  1053.    for (count=1; count <= NumRecs; count++) {
  1054.      fread(&CTXORec, sizeof(CTXORec), 1, HelpFile);
  1055.      printf("Record:%05u    Map ID:0x%08lX     Topic Offset:0x%08lX\n", 
  1056.             count, CTXORec.MapID, CTXORec.TopicOffset);
  1057.    }
  1058. }
  1059.  
  1060.  
  1061.  
  1062. /***************************************************
  1063.   Dumps a given WHIFS file. First thing it does,
  1064.   though, is loads the system rec. This is needed
  1065.   to check if |Phrases or |TOPIC are compressed.
  1066.   After that, it just finds the file and dumps it.
  1067. ****************************************************/
  1068. void DumpFile(FILE *HelpFile) {
  1069.  
  1070.     WORD            FileCounter;
  1071.     char            FileName[20];
  1072.     long            FileOffset, PhrasesOffset;
  1073.  
  1074.  
  1075.     /* Load WHIFSHeader & First Leaf */
  1076.     WHIFSGetFirstLeaf(HelpFile);
  1077.  
  1078.     /* Loads the system record into memory. Need it */
  1079.     /* to determine if compression is used.         */
  1080.  
  1081.     TopicUse = 0;
  1082.     if ((!strcmp(WHIFSFileToRead, "TOPIC")) || (!strcmp(WHIFSFileToRead, "|TOPIC"))) 
  1083.        TopicUse = 1;
  1084.     for (FileCounter = 0; FileCounter < WHIFSHeader.TotalWHIFSEntries; FileCounter++) {
  1085.        GetFile(HelpFile, FileCounter, &FileOffset, FileName);
  1086.        if (!strcmp(FileName, "|SYSTEM"))
  1087.           SysLoad(HelpFile, FileOffset);
  1088.  
  1089.        if ((!strcmp(FileName, "|Phrases")) && (TopicUse))
  1090.           PhrasesOffset = FileOffset;
  1091.     }
  1092.  
  1093.     /* Load Phrases for |TOPIC dump */
  1094.     if (TopicUse) PhraseDump(HelpFile, PhrasesOffset);
  1095.  
  1096.     /* Find the file the user wants to dump */
  1097.  
  1098.     for (FileCounter = 0; FileCounter < WHIFSHeader.TotalWHIFSEntries; FileCounter++) {
  1099.        GetFile(HelpFile, FileCounter, &FileOffset, FileName);
  1100.        if (!strcmp(FileName, WHIFSFileToRead)) break;
  1101.     }
  1102.  
  1103.  
  1104.  
  1105.     if (FileCounter == WHIFSHeader.TotalWHIFSEntries) {
  1106.  
  1107.        /* try appending a | to the filename. */
  1108.        strcpy(FileName, "|");
  1109.        strcat(FileName, WHIFSFileToRead);
  1110.        strcpy(WHIFSFileToRead, FileName);
  1111.  
  1112.        for (FileCounter = 0; FileCounter < WHIFSHeader.TotalWHIFSEntries; FileCounter++) {
  1113.           GetFile(HelpFile, FileCounter, &FileOffset, FileName);
  1114.           if (!strcmp(FileName, WHIFSFileToRead)) break;
  1115.        }
  1116.     }
  1117.  
  1118.  
  1119.     /* Bad file! */
  1120.  
  1121.     if (FileCounter == WHIFSHeader.TotalWHIFSEntries) {
  1122.        printf("File %s not found in help file.\n", WHIFSFileToRead);
  1123.        return;
  1124.     }
  1125.  
  1126.     if (!strcmp(FileName, "|SYSTEM"))
  1127.         SysDump(HelpFile, FileOffset);
  1128.     else if (!strcmp(FileName, "|Phrases"))
  1129.         PhraseDump(HelpFile, FileOffset);
  1130.     else if (!strcmp(FileName, "|FONT"))
  1131.         FontDump(HelpFile, FileOffset);
  1132.     else if (!strcmp(FileName, "|TOMAP"))
  1133.         ToMapDump(HelpFile, FileOffset);
  1134.     else if (!strcmp(FileName, "|TOPIC"))
  1135.     TopicDump(HelpFile, FileOffset);
  1136.     else if (!strcmp(FileName, "|TTLBTREE"))
  1137.         TTLDump(HelpFile, FileOffset); 
  1138.     else if (!strcmp(FileName, "|KWMAP"))
  1139.         KWMapDump(HelpFile, FileOffset);
  1140.     else if (!strcmp(FileName, "|KWDATA"))
  1141.         KWDataDump(HelpFile, FileOffset);
  1142.     else if (!strcmp(FileName, "|KWBTREE"))
  1143.         KWBTreeDump(HelpFile, FileOffset);
  1144.     else if (!strcmp(FileName, "|CONTEXT"))
  1145.         ContextDump(HelpFile, FileOffset); 
  1146.     else if (!strcmp(FileName, "|CTXOMAP"))
  1147.         CTXOMAPDump(HelpFile, FileOffset);
  1148.     else 
  1149.         HexDump(HelpFile, FileOffset);
  1150.  
  1151.  
  1152. }
  1153.  
  1154.  
  1155.  
  1156. /***************************************************
  1157.    Read the Help Header then build the WHIFS B-Tree.
  1158.    Show the WHIFS directory to the user and see what
  1159.    they want to do. (See a file or quit?)
  1160. ****************************************************/
  1161.  
  1162. void HelpDump(FILE *HelpFile) {
  1163.  
  1164.  
  1165.     fread(&HelpHeader, sizeof(HelpHeader), 1, HelpFile);
  1166.     if (HelpHeader.MagicNumber != 0x000000035F3F) {
  1167.     printf("Fatal Error:\n");
  1168.     printf("  Not a valid WinHelp file!\n");
  1169.     return;
  1170.     }
  1171.  
  1172.     if (ReadWHIFSFile) 
  1173.        DumpFile(HelpFile);
  1174.     else
  1175.        ListFiles(HelpFile);
  1176.  
  1177. }
  1178.  
  1179.  
  1180.  
  1181. /***************************************************
  1182.   Show usage.
  1183. ****************************************************/
  1184.  
  1185. void Usage() {
  1186.  
  1187.   printf("Usage:\n");
  1188.   printf(" HELPDUMP helpfile[.hlp] [WHIFSFilename]\n\n\n");
  1189.   printf("   helpfile      - Name of help file (.HLP or .MVB)\n");
  1190.   printf("   WHIFSFilename - Name of internal file to view\n\n");
  1191.   printf(" If only a helpfile is provided, the WHIFS directory is shown.\n");
  1192.   printf(" Provide a WHIFSFilename to display an internal file.\n");
  1193.  
  1194. }
  1195.  
  1196.  
  1197.  
  1198. /***************************************************
  1199.   Open the file and dump it.
  1200. ****************************************************/
  1201.  
  1202. int main(int argc, char *argv[]) {
  1203.  
  1204.     char filename[40];
  1205.     FILE *HelpFile;
  1206.  
  1207.     if (argc < 2) {
  1208.        Usage();
  1209.        return EXIT_FAILURE;
  1210.     }
  1211.     ReadWHIFSFile = 0;
  1212.     if (argc == 3) {
  1213.        strcpy(WHIFSFileToRead, argv[2]);
  1214.        ReadWHIFSFile = 1;
  1215.     }
  1216.  
  1217.     strcpy(filename, argv[1]);
  1218.     strupr(filename);
  1219.     if (!strchr(filename, '.')) 
  1220.        strcat(filename, ".HLP");
  1221.  
  1222.     if ((HelpFile = fopen(filename, "rb")) == NULL) {
  1223.        printf("%s does not exist!", filename);
  1224.        return EXIT_FAILURE;
  1225.     }
  1226.  
  1227.     HelpDump(HelpFile);
  1228.     fclose(HelpFile);
  1229.  
  1230.     return EXIT_SUCCESS;
  1231. }
  1232. 
  1233.